var Module = (() => {
  var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src :
    undefined;
  if (typeof __filename !== 'undefined') _scriptDir = _scriptDir || __filename;
  return (
    function(Module) {
      Module = Module || {};

      var Module = typeof Module !== "undefined" ? Module : {};
      var objAssign = Object.assign;
      var readyPromiseResolve, readyPromiseReject;
      Module["ready"] = new Promise(function(resolve, reject) {
        readyPromiseResolve = resolve;
        readyPromiseReject = reject
      });
      var moduleOverrides = objAssign({}, Module);
      var arguments_ = [];
      var thisProgram = "./this.program";
      var quit_ = (status, toThrow) => {
        throw toThrow
      };
      var ENVIRONMENT_IS_WEB = typeof window === "object";
      var ENVIRONMENT_IS_WORKER = typeof importScripts === "function";
      var ENVIRONMENT_IS_NODE = typeof process === "object" && typeof process.versions === "object" &&
        typeof process.versions.node === "string";
      var scriptDirectory = "";

      function locateFile(path) {
        if (Module["locateFile"]) {
          return Module["locateFile"](path, scriptDirectory)
        }
        return scriptDirectory + path
      }
      var read_, readAsync, readBinary, setWindowTitle;

      function logExceptionOnExit(e) {
        if (e instanceof ExitStatus) return;
        let toLog = e;
        err("exiting due to exception: " + toLog)
      }
      var fs;
      var nodePath;
      var requireNodeFS;
      if (ENVIRONMENT_IS_NODE) {
        if (ENVIRONMENT_IS_WORKER) {
          scriptDirectory = require("path").dirname(scriptDirectory) + "/"
        } else {
          scriptDirectory = __dirname + "/"
        }
        requireNodeFS = function() {
          if (!nodePath) {
            fs = require("fs");
            nodePath = require("path")
          }
        };
        read_ = function shell_read(filename, binary) {
          requireNodeFS();
          filename = nodePath["normalize"](filename);
          return fs.readFileSync(filename, binary ? null : "utf8")
        };
        readBinary = function readBinary(filename) {
          var ret = read_(filename, true);
          if (!ret.buffer) {
            ret = new Uint8Array(ret)
          }
          return ret
        };
        readAsync = function readAsync(filename, onload, onerror) {
          requireNodeFS();
          filename = nodePath["normalize"](filename);
          fs.readFile(filename, function(err, data) {
            if (err) onerror(err);
            else onload(data.buffer)
          })
        };
        if (process["argv"].length > 1) {
          thisProgram = process["argv"][1].replace(/\\/g, "/")
        }
        arguments_ = process["argv"].slice(2);
        process["on"]("uncaughtException", function(ex) {
          if (!(ex instanceof ExitStatus)) {
            throw ex
          }
        });
        process["on"]("unhandledRejection", function(reason) {
          throw reason
        });
        quit_ = ((status, toThrow) => {
          if (keepRuntimeAlive()) {
            process["exitCode"] = status;
            throw toThrow
          }
          logExceptionOnExit(toThrow);
          process["exit"](status)
        });
        Module["inspect"] = function() {
          return "[Emscripten Module object]"
        }
      } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
        if (ENVIRONMENT_IS_WORKER) {
          scriptDirectory = self.location.href
        } else if (typeof document !== "undefined" && document.currentScript) {
          scriptDirectory = document.currentScript.src
        }
        if (_scriptDir) {
          scriptDirectory = _scriptDir
        }
        if (scriptDirectory.indexOf("blob:") !== 0) {
          scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1)
        } else {
          scriptDirectory = ""
        } {
          read_ = function(url) {
            var xhr = new XMLHttpRequest;
            xhr.open("GET", url, false);
            xhr.send(null);
            return xhr.responseText
          };
          if (ENVIRONMENT_IS_WORKER) {
            readBinary = function(url) {
              var xhr = new XMLHttpRequest;
              xhr.open("GET", url, false);
              xhr.responseType = "arraybuffer";
              xhr.send(null);
              return new Uint8Array(xhr.response)
            }
          }
          readAsync = function(url, onload, onerror) {
            var xhr = new XMLHttpRequest;
            xhr.open("GET", url, true);
            xhr.responseType = "arraybuffer";
            xhr.onload = function() {
              if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
                onload(xhr.response);
                return
              }
              onerror()
            };
            xhr.onerror = onerror;
            xhr.send(null)
          }
        }
        setWindowTitle = (title => document.title = title)
      } else {}
      var out = Module["print"] || console.log.bind(console);
      var err = Module["printErr"] || console.warn.bind(console);
      objAssign(Module, moduleOverrides);
      moduleOverrides = null;
      if (Module["arguments"]) arguments_ = Module["arguments"];
      if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
      if (Module["quit"]) quit_ = Module["quit"];

      function convertJsFunctionToWasm(func, sig) {
        if (typeof WebAssembly.Function === "function") {
          var typeNames = {
            "i": "i32",
            "j": "i64",
            "f": "f32",
            "d": "f64"
          };
          var type = {
            parameters: [],
            results: sig[0] == "v" ? [] : [typeNames[sig[0]]]
          };
          for (var i = 1; i < sig.length; ++i) {
            type.parameters.push(typeNames[sig[i]])
          }
          return new WebAssembly.Function(type, func)
        }
        var typeSection = [1, 0, 1, 96];
        var sigRet = sig.slice(0, 1);
        var sigParam = sig.slice(1);
        var typeCodes = {
          "i": 127,
          "j": 126,
          "f": 125,
          "d": 124
        };
        typeSection.push(sigParam.length);
        for (var i = 0; i < sigParam.length; ++i) {
          typeSection.push(typeCodes[sigParam[i]])
        }
        if (sigRet == "v") {
          typeSection.push(0)
        } else {
          typeSection = typeSection.concat([1, typeCodes[sigRet]])
        }
        typeSection[1] = typeSection.length - 2;
        var bytes = new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0].concat(typeSection, [2, 7, 1, 1, 101, 1, 102, 0,
          0, 7, 5, 1, 1, 102, 0, 0
        ]));
        var module = new WebAssembly.Module(bytes);
        var instance = new WebAssembly.Instance(module, {
          "e": {
            "f": func
          }
        });
        var wrappedFunc = instance.exports["f"];
        return wrappedFunc
      }
      var freeTableIndexes = [];
      var functionsInTableMap;

      function getEmptyTableSlot() {
        if (freeTableIndexes.length) {
          return freeTableIndexes.pop()
        }
        try {
          wasmTable.grow(1)
        } catch (err) {
          if (!(err instanceof RangeError)) {
            throw err
          }
          throw "Unable to grow wasm table. Set ALLOW_TABLE_GROWTH."
        }
        return wasmTable.length - 1
      }

      function updateTableMap(offset, count) {
        for (var i = offset; i < offset + count; i++) {
          var item = getWasmTableEntry(i);
          if (item) {
            functionsInTableMap.set(item, i)
          }
        }
      }

      function addFunction(func, sig) {
        if (!functionsInTableMap) {
          functionsInTableMap = new WeakMap;
          updateTableMap(0, wasmTable.length)
        }
        if (functionsInTableMap.has(func)) {
          return functionsInTableMap.get(func)
        }
        var ret = getEmptyTableSlot();
        try {
          setWasmTableEntry(ret, func)
        } catch (err) {
          if (!(err instanceof TypeError)) {
            throw err
          }
          var wrapped = convertJsFunctionToWasm(func, sig);
          setWasmTableEntry(ret, wrapped)
        }
        functionsInTableMap.set(func, ret);
        return ret
      }
      var wasmBinary;
      if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
      var noExitRuntime = Module["noExitRuntime"] || true;
      if (typeof WebAssembly !== "object") {
        abort("no native wasm support detected")
      }
      var wasmMemory;
      var ABORT = false;
      var EXITSTATUS;

      function getCFunc(ident) {
        var func = Module["_" + ident];
        return func
      }

      function ccall(ident, returnType, argTypes, args, opts) {
        var toC = {
          "string": function(str) {
            var ret = 0;
            if (str !== null && str !== undefined && str !== 0) {
              var len = (str.length << 2) + 1;
              ret = stackAlloc(len);
              stringToUTF8(str, ret, len)
            }
            return ret
          },
          "array": function(arr) {
            var ret = stackAlloc(arr.length);
            writeArrayToMemory(arr, ret);
            return ret
          }
        };

        function convertReturnValue(ret) {
          if (returnType === "string") return UTF8ToString(ret);
          if (returnType === "boolean") return Boolean(ret);
          return ret
        }
        var func = getCFunc(ident);
        var cArgs = [];
        var stack = 0;
        if (args) {
          for (var i = 0; i < args.length; i++) {
            var converter = toC[argTypes[i]];
            if (converter) {
              if (stack === 0) stack = stackSave();
              cArgs[i] = converter(args[i])
            } else {
              cArgs[i] = args[i]
            }
          }
        }
        var ret = func.apply(null, cArgs);

        function onDone(ret) {
          if (stack !== 0) stackRestore(stack);
          return convertReturnValue(ret)
        }
        ret = onDone(ret);
        return ret
      }
      var UTF8Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf8") : undefined;

      function UTF8ArrayToString(heap, idx, maxBytesToRead) {
        var endIdx = idx + maxBytesToRead;
        var endPtr = idx;
        while (heap[endPtr] && !(endPtr >= endIdx)) ++endPtr;
        if (endPtr - idx > 16 && heap.subarray && UTF8Decoder) {
          return UTF8Decoder.decode(heap.subarray(idx, endPtr))
        } else {
          var str = "";
          while (idx < endPtr) {
            var u0 = heap[idx++];
            if (!(u0 & 128)) {
              str += String.fromCharCode(u0);
              continue
            }
            var u1 = heap[idx++] & 63;
            if ((u0 & 224) == 192) {
              str += String.fromCharCode((u0 & 31) << 6 | u1);
              continue
            }
            var u2 = heap[idx++] & 63;
            if ((u0 & 240) == 224) {
              u0 = (u0 & 15) << 12 | u1 << 6 | u2
            } else {
              u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heap[idx++] & 63
            }
            if (u0 < 65536) {
              str += String.fromCharCode(u0)
            } else {
              var ch = u0 - 65536;
              str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023)
            }
          }
        }
        return str
      }

      function UTF8ToString(ptr, maxBytesToRead) {
        return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : ""
      }

      function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {
        if (!(maxBytesToWrite > 0)) return 0;
        var startIdx = outIdx;
        var endIdx = outIdx + maxBytesToWrite - 1;
        for (var i = 0; i < str.length; ++i) {
          var u = str.charCodeAt(i);
          if (u >= 55296 && u <= 57343) {
            var u1 = str.charCodeAt(++i);
            u = 65536 + ((u & 1023) << 10) | u1 & 1023
          }
          if (u <= 127) {
            if (outIdx >= endIdx) break;
            heap[outIdx++] = u
          } else if (u <= 2047) {
            if (outIdx + 1 >= endIdx) break;
            heap[outIdx++] = 192 | u >> 6;
            heap[outIdx++] = 128 | u & 63
          } else if (u <= 65535) {
            if (outIdx + 2 >= endIdx) break;
            heap[outIdx++] = 224 | u >> 12;
            heap[outIdx++] = 128 | u >> 6 & 63;
            heap[outIdx++] = 128 | u & 63
          } else {
            if (outIdx + 3 >= endIdx) break;
            heap[outIdx++] = 240 | u >> 18;
            heap[outIdx++] = 128 | u >> 12 & 63;
            heap[outIdx++] = 128 | u >> 6 & 63;
            heap[outIdx++] = 128 | u & 63
          }
        }
        heap[outIdx] = 0;
        return outIdx - startIdx
      }

      function stringToUTF8(str, outPtr, maxBytesToWrite) {
        return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite)
      }

      function writeArrayToMemory(array, buffer) {
        HEAP8.set(array, buffer)
      }

      function alignUp(x, multiple) {
        if (x % multiple > 0) {
          x += multiple - x % multiple
        }
        return x
      }
      var buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;

      function updateGlobalBufferAndViews(buf) {
        buffer = buf;
        Module["HEAP8"] = HEAP8 = new Int8Array(buf);
        Module["HEAP16"] = HEAP16 = new Int16Array(buf);
        Module["HEAP32"] = HEAP32 = new Int32Array(buf);
        Module["HEAPU8"] = HEAPU8 = new Uint8Array(buf);
        Module["HEAPU16"] = HEAPU16 = new Uint16Array(buf);
        Module["HEAPU32"] = HEAPU32 = new Uint32Array(buf);
        Module["HEAPF32"] = HEAPF32 = new Float32Array(buf);
        Module["HEAPF64"] = HEAPF64 = new Float64Array(buf)
      }
      var INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 16777216;
      var wasmTable;
      var __ATPRERUN__ = [];
      var __ATINIT__ = [];
      var __ATPOSTRUN__ = [];
      var runtimeInitialized = false;
      var runtimeKeepaliveCounter = 0;

      function keepRuntimeAlive() {
        return noExitRuntime || runtimeKeepaliveCounter > 0
      }

      function preRun() {
        if (Module["preRun"]) {
          if (typeof Module["preRun"] == "function") Module["preRun"] = [Module["preRun"]];
          while (Module["preRun"].length) {
            addOnPreRun(Module["preRun"].shift())
          }
        }
        callRuntimeCallbacks(__ATPRERUN__)
      }

      function initRuntime() {
        runtimeInitialized = true;
        callRuntimeCallbacks(__ATINIT__)
      }

      function postRun() {
        if (Module["postRun"]) {
          if (typeof Module["postRun"] == "function") Module["postRun"] = [Module["postRun"]];
          while (Module["postRun"].length) {
            addOnPostRun(Module["postRun"].shift())
          }
        }
        callRuntimeCallbacks(__ATPOSTRUN__)
      }

      function addOnPreRun(cb) {
        __ATPRERUN__.unshift(cb)
      }

      function addOnInit(cb) {
        __ATINIT__.unshift(cb)
      }

      function addOnPostRun(cb) {
        __ATPOSTRUN__.unshift(cb)
      }
      var runDependencies = 0;
      var runDependencyWatcher = null;
      var dependenciesFulfilled = null;

      function addRunDependency(id) {
        runDependencies++;
        if (Module["monitorRunDependencies"]) {
          Module["monitorRunDependencies"](runDependencies)
        }
      }

      function removeRunDependency(id) {
        runDependencies--;
        if (Module["monitorRunDependencies"]) {
          Module["monitorRunDependencies"](runDependencies)
        }
        if (runDependencies == 0) {
          if (runDependencyWatcher !== null) {
            clearInterval(runDependencyWatcher);
            runDependencyWatcher = null
          }
          if (dependenciesFulfilled) {
            var callback = dependenciesFulfilled;
            dependenciesFulfilled = null;
            callback()
          }
        }
      }
      Module["preloadedImages"] = {};
      Module["preloadedAudios"] = {};

      function abort(what) {
        {
          if (Module["onAbort"]) {
            Module["onAbort"](what)
          }
        }
        what = "Aborted(" + what + ")";
        err(what);
        ABORT = true;
        EXITSTATUS = 1;
        what += ". Build with -s ASSERTIONS=1 for more info.";
        var e = new WebAssembly.RuntimeError(what);
        readyPromiseReject(e);
        throw e
      }
      var dataURIPrefix = "data:application/octet-stream;base64,";

      function isDataURI(filename) {
        return filename.startsWith(dataURIPrefix)
      }

      function isFileURI(filename) {
        return filename.startsWith("file://")
      }
      var wasmBinaryFile;
      wasmBinaryFile = "Live2DCubismCore.wasm";
      if (!isDataURI(wasmBinaryFile)) {
        wasmBinaryFile = locateFile(wasmBinaryFile)
      }

      function getBinary(file) {
        try {
          if (file == wasmBinaryFile && wasmBinary) {
            return new Uint8Array(wasmBinary)
          }
          if (readBinary) {
            return readBinary(file)
          } else {
            throw "both async and sync fetching of the wasm failed"
          }
        } catch (err) {
          abort(err)
        }
      }

      function getBinaryPromise() {
        if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
          if (typeof fetch === "function" && !isFileURI(wasmBinaryFile)) {
            return fetch(wasmBinaryFile, {
              credentials: "same-origin"
            }).then(function(response) {
              if (!response["ok"]) {
                throw "failed to load wasm binary file at '" + wasmBinaryFile + "'"
              }
              return response["arrayBuffer"]()
            }).catch(function() {
              return getBinary(wasmBinaryFile)
            })
          } else {
            if (readAsync) {
              return new Promise(function(resolve, reject) {
                readAsync(wasmBinaryFile, function(response) {
                  resolve(new Uint8Array(response))
                }, reject)
              })
            }
          }
        }
        return Promise.resolve().then(function() {
          return getBinary(wasmBinaryFile)
        })
      }

      function createWasm() {
        var info = {
          "a": asmLibraryArg
        };

        function receiveInstance(instance, module) {
          var exports = instance.exports;
          Module["asm"] = exports;
          wasmMemory = Module["asm"]["c"];
          updateGlobalBufferAndViews(wasmMemory.buffer);
          wasmTable = Module["asm"]["f"];
          addOnInit(Module["asm"]["d"]);
          removeRunDependency("wasm-instantiate")
        }
        addRunDependency("wasm-instantiate");

        function receiveInstantiationResult(result) {
          receiveInstance(result["instance"])
        }

        function instantiateArrayBuffer(receiver) {
          return getBinaryPromise().then(function(binary) {
            return WebAssembly.instantiate(binary, info)
          }).then(function(instance) {
            return instance
          }).then(receiver, function(reason) {
            err("failed to asynchronously prepare wasm: " + reason);
            abort(reason)
          })
        }

        function instantiateAsync() {
          if (!wasmBinary && typeof WebAssembly.instantiateStreaming === "function" && !isDataURI(
            wasmBinaryFile) && !isFileURI(wasmBinaryFile) && typeof fetch === "function") {
            return fetch(wasmBinaryFile, {
              credentials: "same-origin"
            }).then(function(response) {
              var result = WebAssembly.instantiateStreaming(response, info);
              return result.then(receiveInstantiationResult, function(reason) {
                err("wasm streaming compile failed: " + reason);
                err("falling back to ArrayBuffer instantiation");
                return instantiateArrayBuffer(receiveInstantiationResult)
              })
            })
          } else {
            return instantiateArrayBuffer(receiveInstantiationResult)
          }
        }
        if (Module["instantiateWasm"]) {
          try {
            var exports = Module["instantiateWasm"](info, receiveInstance);
            return exports
          } catch (e) {
            err("Module.instantiateWasm callback failed with error: " + e);
            return false
          }
        }
        instantiateAsync().catch(readyPromiseReject);
        return {}
      }

      function callRuntimeCallbacks(callbacks) {
        while (callbacks.length > 0) {
          var callback = callbacks.shift();
          if (typeof callback == "function") {
            callback(Module);
            continue
          }
          var func = callback.func;
          if (typeof func === "number") {
            if (callback.arg === undefined) {
              getWasmTableEntry(func)()
            } else {
              getWasmTableEntry(func)(callback.arg)
            }
          } else {
            func(callback.arg === undefined ? null : callback.arg)
          }
        }
      }

      function getWasmTableEntry(funcPtr) {
        return wasmTable.get(funcPtr)
      }

      function setWasmTableEntry(idx, func) {
        wasmTable.set(idx, func)
      }

      function emscripten_realloc_buffer(size) {
        try {
          wasmMemory.grow(size - buffer.byteLength + 65535 >>> 16);
          updateGlobalBufferAndViews(wasmMemory.buffer);
          return 1
        } catch (e) {}
      }

      function _emscripten_resize_heap(requestedSize) {
        var oldSize = HEAPU8.length;
        requestedSize = requestedSize >>> 0;
        var maxHeapSize = 2147483648;
        if (requestedSize > maxHeapSize) {
          return false
        }
        for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
          var overGrownHeapSize = oldSize * (1 + .2 / cutDown);
          overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
          var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536));
          var replacement = emscripten_realloc_buffer(newSize);
          if (replacement) {
            return true
          }
        }
        return false
      }
      var SYSCALLS = {
        mappings: {},
        buffers: [null, [],
          []
        ],
        printChar: function(stream, curr) {
          var buffer = SYSCALLS.buffers[stream];
          if (curr === 0 || curr === 10) {
            (stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0));
            buffer.length = 0
          } else {
            buffer.push(curr)
          }
        },
        varargs: undefined,
        get: function() {
          SYSCALLS.varargs += 4;
          var ret = HEAP32[SYSCALLS.varargs - 4 >> 2];
          return ret
        },
        getStr: function(ptr) {
          var ret = UTF8ToString(ptr);
          return ret
        },
        get64: function(low, high) {
          return low
        }
      };

      function _fd_write(fd, iov, iovcnt, pnum) {
        var num = 0;
        for (var i = 0; i < iovcnt; i++) {
          var ptr = HEAP32[iov >> 2];
          var len = HEAP32[iov + 4 >> 2];
          iov += 8;
          for (var j = 0; j < len; j++) {
            SYSCALLS.printChar(fd, HEAPU8[ptr + j])
          }
          num += len
        }
        HEAP32[pnum >> 2] = num;
        return 0
      }
      var asmLibraryArg = {
        "b": _emscripten_resize_heap,
        "a": _fd_write
      };
      var asm = createWasm();
      var ___wasm_call_ctors = Module["___wasm_call_ctors"] = function() {
        return (___wasm_call_ctors = Module["___wasm_call_ctors"] = Module["asm"]["d"]).apply(null, arguments)
      };
      var _csmGetLogFunction = Module["_csmGetLogFunction"] = function() {
        return (_csmGetLogFunction = Module["_csmGetLogFunction"] = Module["asm"]["e"]).apply(null, arguments)
      };
      var _csmGetVersion = Module["_csmGetVersion"] = function() {
        return (_csmGetVersion = Module["_csmGetVersion"] = Module["asm"]["g"]).apply(null, arguments)
      };
      var _csmGetLatestMocVersion = Module["_csmGetLatestMocVersion"] = function() {
        return (_csmGetLatestMocVersion = Module["_csmGetLatestMocVersion"] = Module["asm"]["h"]).apply(null,
          arguments)
      };
      var _csmGetMocVersion = Module["_csmGetMocVersion"] = function() {
        return (_csmGetMocVersion = Module["_csmGetMocVersion"] = Module["asm"]["i"]).apply(null, arguments)
      };
      var _csmHasMocConsistency = Module["_csmHasMocConsistency"] = function() {
        return (_csmHasMocConsistency = Module["_csmHasMocConsistency"] = Module["asm"]["j"]).apply(null,
          arguments)
      };
      var _csmSetLogFunction = Module["_csmSetLogFunction"] = function() {
        return (_csmSetLogFunction = Module["_csmSetLogFunction"] = Module["asm"]["k"]).apply(null, arguments)
      };
      var _csmReviveMocInPlace = Module["_csmReviveMocInPlace"] = function() {
        return (_csmReviveMocInPlace = Module["_csmReviveMocInPlace"] = Module["asm"]["l"]).apply(null,
          arguments)
      };
      var _csmReadCanvasInfo = Module["_csmReadCanvasInfo"] = function() {
        return (_csmReadCanvasInfo = Module["_csmReadCanvasInfo"] = Module["asm"]["m"]).apply(null, arguments)
      };
      var _csmGetSizeofModel = Module["_csmGetSizeofModel"] = function() {
        return (_csmGetSizeofModel = Module["_csmGetSizeofModel"] = Module["asm"]["n"]).apply(null, arguments)
      };
      var _csmInitializeModelInPlace = Module["_csmInitializeModelInPlace"] = function() {
        return (_csmInitializeModelInPlace = Module["_csmInitializeModelInPlace"] = Module["asm"]["o"]).apply(
          null, arguments)
      };
      var _csmUpdateModel = Module["_csmUpdateModel"] = function() {
        return (_csmUpdateModel = Module["_csmUpdateModel"] = Module["asm"]["p"]).apply(null, arguments)
      };
      var _csmGetParameterCount = Module["_csmGetParameterCount"] = function() {
        return (_csmGetParameterCount = Module["_csmGetParameterCount"] = Module["asm"]["q"]).apply(null,
          arguments)
      };
      var _csmGetParameterIds = Module["_csmGetParameterIds"] = function() {
        return (_csmGetParameterIds = Module["_csmGetParameterIds"] = Module["asm"]["r"]).apply(null, arguments)
      };
      var _csmGetParameterTypes = Module["_csmGetParameterTypes"] = function() {
        return (_csmGetParameterTypes = Module["_csmGetParameterTypes"] = Module["asm"]["s"]).apply(null,
          arguments)
      };
      var _csmGetParameterMinimumValues = Module["_csmGetParameterMinimumValues"] = function() {
        return (_csmGetParameterMinimumValues = Module["_csmGetParameterMinimumValues"] = Module["asm"]["t"])
          .apply(null, arguments)
      };
      var _csmGetParameterMaximumValues = Module["_csmGetParameterMaximumValues"] = function() {
        return (_csmGetParameterMaximumValues = Module["_csmGetParameterMaximumValues"] = Module["asm"]["u"])
          .apply(null, arguments)
      };
      var _csmGetParameterDefaultValues = Module["_csmGetParameterDefaultValues"] = function() {
        return (_csmGetParameterDefaultValues = Module["_csmGetParameterDefaultValues"] = Module["asm"]["v"])
          .apply(null, arguments)
      };
      var _csmGetParameterValues = Module["_csmGetParameterValues"] = function() {
        return (_csmGetParameterValues = Module["_csmGetParameterValues"] = Module["asm"]["w"]).apply(null,
          arguments)
      };
      var _csmGetPartCount = Module["_csmGetPartCount"] = function() {
        return (_csmGetPartCount = Module["_csmGetPartCount"] = Module["asm"]["x"]).apply(null, arguments)
      };
      var _csmGetPartIds = Module["_csmGetPartIds"] = function() {
        return (_csmGetPartIds = Module["_csmGetPartIds"] = Module["asm"]["y"]).apply(null, arguments)
      };
      var _csmGetPartOpacities = Module["_csmGetPartOpacities"] = function() {
        return (_csmGetPartOpacities = Module["_csmGetPartOpacities"] = Module["asm"]["z"]).apply(null,
          arguments)
      };
      var _csmGetPartParentPartIndices = Module["_csmGetPartParentPartIndices"] = function() {
        return (_csmGetPartParentPartIndices = Module["_csmGetPartParentPartIndices"] = Module["asm"]["A"])
          .apply(null, arguments)
      };
      var _csmGetDrawableCount = Module["_csmGetDrawableCount"] = function() {
        return (_csmGetDrawableCount = Module["_csmGetDrawableCount"] = Module["asm"]["B"]).apply(null,
          arguments)
      };
      var _csmGetDrawableIds = Module["_csmGetDrawableIds"] = function() {
        return (_csmGetDrawableIds = Module["_csmGetDrawableIds"] = Module["asm"]["C"]).apply(null, arguments)
      };
      var _csmGetDrawableConstantFlags = Module["_csmGetDrawableConstantFlags"] = function() {
        return (_csmGetDrawableConstantFlags = Module["_csmGetDrawableConstantFlags"] = Module["asm"]["D"])
          .apply(null, arguments)
      };
      var _csmGetDrawableDynamicFlags = Module["_csmGetDrawableDynamicFlags"] = function() {
        return (_csmGetDrawableDynamicFlags = Module["_csmGetDrawableDynamicFlags"] = Module["asm"]["E"]).apply(
          null, arguments)
      };
      var _csmGetDrawableTextureIndices = Module["_csmGetDrawableTextureIndices"] = function() {
        return (_csmGetDrawableTextureIndices = Module["_csmGetDrawableTextureIndices"] = Module["asm"]["F"])
          .apply(null, arguments)
      };
      var _csmGetDrawableDrawOrders = Module["_csmGetDrawableDrawOrders"] = function() {
        return (_csmGetDrawableDrawOrders = Module["_csmGetDrawableDrawOrders"] = Module["asm"]["G"]).apply(
          null, arguments)
      };
      var _csmGetDrawableRenderOrders = Module["_csmGetDrawableRenderOrders"] = function() {
        return (_csmGetDrawableRenderOrders = Module["_csmGetDrawableRenderOrders"] = Module["asm"]["H"]).apply(
          null, arguments)
      };
      var _csmGetDrawableOpacities = Module["_csmGetDrawableOpacities"] = function() {
        return (_csmGetDrawableOpacities = Module["_csmGetDrawableOpacities"] = Module["asm"]["I"]).apply(null,
          arguments)
      };
      var _csmGetDrawableMaskCounts = Module["_csmGetDrawableMaskCounts"] = function() {
        return (_csmGetDrawableMaskCounts = Module["_csmGetDrawableMaskCounts"] = Module["asm"]["J"]).apply(
          null, arguments)
      };
      var _csmGetDrawableMasks = Module["_csmGetDrawableMasks"] = function() {
        return (_csmGetDrawableMasks = Module["_csmGetDrawableMasks"] = Module["asm"]["K"]).apply(null,
          arguments)
      };
      var _csmGetDrawableVertexCounts = Module["_csmGetDrawableVertexCounts"] = function() {
        return (_csmGetDrawableVertexCounts = Module["_csmGetDrawableVertexCounts"] = Module["asm"]["L"]).apply(
          null, arguments)
      };
      var _csmGetDrawableVertexPositions = Module["_csmGetDrawableVertexPositions"] = function() {
        return (_csmGetDrawableVertexPositions = Module["_csmGetDrawableVertexPositions"] = Module["asm"]["M"])
          .apply(null, arguments)
      };
      var _csmGetDrawableVertexUvs = Module["_csmGetDrawableVertexUvs"] = function() {
        return (_csmGetDrawableVertexUvs = Module["_csmGetDrawableVertexUvs"] = Module["asm"]["N"]).apply(null,
          arguments)
      };
      var _csmGetDrawableIndexCounts = Module["_csmGetDrawableIndexCounts"] = function() {
        return (_csmGetDrawableIndexCounts = Module["_csmGetDrawableIndexCounts"] = Module["asm"]["O"]).apply(
          null, arguments)
      };
      var _csmGetDrawableIndices = Module["_csmGetDrawableIndices"] = function() {
        return (_csmGetDrawableIndices = Module["_csmGetDrawableIndices"] = Module["asm"]["P"]).apply(null,
          arguments)
      };
      var _csmGetDrawableMultiplyColors = Module["_csmGetDrawableMultiplyColors"] = function() {
        return (_csmGetDrawableMultiplyColors = Module["_csmGetDrawableMultiplyColors"] = Module["asm"]["Q"])
          .apply(null, arguments)
      };
      var _csmGetDrawableScreenColors = Module["_csmGetDrawableScreenColors"] = function() {
        return (_csmGetDrawableScreenColors = Module["_csmGetDrawableScreenColors"] = Module["asm"]["R"]).apply(
          null, arguments)
      };
      var _csmGetDrawableParentPartIndices = Module["_csmGetDrawableParentPartIndices"] = function() {
        return (_csmGetDrawableParentPartIndices = Module["_csmGetDrawableParentPartIndices"] = Module["asm"][
          "S"
        ]).apply(null, arguments)
      };
      var _csmResetDrawableDynamicFlags = Module["_csmResetDrawableDynamicFlags"] = function() {
        return (_csmResetDrawableDynamicFlags = Module["_csmResetDrawableDynamicFlags"] = Module["asm"]["T"])
          .apply(null, arguments)
      };
      var _csmGetParameterKeyCounts = Module["_csmGetParameterKeyCounts"] = function() {
        return (_csmGetParameterKeyCounts = Module["_csmGetParameterKeyCounts"] = Module["asm"]["U"]).apply(
          null, arguments)
      };
      var _csmGetParameterKeyValues = Module["_csmGetParameterKeyValues"] = function() {
        return (_csmGetParameterKeyValues = Module["_csmGetParameterKeyValues"] = Module["asm"]["V"]).apply(
          null, arguments)
      };
      var _csmMallocMoc = Module["_csmMallocMoc"] = function() {
        return (_csmMallocMoc = Module["_csmMallocMoc"] = Module["asm"]["W"]).apply(null, arguments)
      };
      var _csmMallocModelAndInitialize = Module["_csmMallocModelAndInitialize"] = function() {
        return (_csmMallocModelAndInitialize = Module["_csmMallocModelAndInitialize"] = Module["asm"]["X"])
          .apply(null, arguments)
      };
      var _csmMalloc = Module["_csmMalloc"] = function() {
        return (_csmMalloc = Module["_csmMalloc"] = Module["asm"]["Y"]).apply(null, arguments)
      };
      var _csmFree = Module["_csmFree"] = function() {
        return (_csmFree = Module["_csmFree"] = Module["asm"]["Z"]).apply(null, arguments)
      };
      var stackSave = Module["stackSave"] = function() {
        return (stackSave = Module["stackSave"] = Module["asm"]["_"]).apply(null, arguments)
      };
      var stackRestore = Module["stackRestore"] = function() {
        return (stackRestore = Module["stackRestore"] = Module["asm"]["$"]).apply(null, arguments)
      };
      var stackAlloc = Module["stackAlloc"] = function() {
        return (stackAlloc = Module["stackAlloc"] = Module["asm"]["aa"]).apply(null, arguments)
      };
      Module["ccall"] = ccall;
      Module["UTF8ToString"] = UTF8ToString;
      Module["addFunction"] = addFunction;
      var calledRun;

      function ExitStatus(status) {
        this.name = "ExitStatus";
        this.message = "Program terminated with exit(" + status + ")";
        this.status = status
      }
      dependenciesFulfilled = function runCaller() {
        if (!calledRun) run();
        if (!calledRun) dependenciesFulfilled = runCaller
      };

      function run(args) {
        args = args || arguments_;
        if (runDependencies > 0) {
          return
        }
        preRun();
        if (runDependencies > 0) {
          return
        }

        function doRun() {
          if (calledRun) return;
          calledRun = true;
          Module["calledRun"] = true;
          if (ABORT) return;
          initRuntime();
          readyPromiseResolve(Module);
          if (Module["onRuntimeInitialized"]) Module["onRuntimeInitialized"]();
          postRun()
        }
        if (Module["setStatus"]) {
          Module["setStatus"]("Running...");
          setTimeout(function() {
            setTimeout(function() {
              Module["setStatus"]("")
            }, 1);
            doRun()
          }, 1)
        } else {
          doRun()
        }
      }
      Module["run"] = run;
      if (Module["preInit"]) {
        if (typeof Module["preInit"] == "function") Module["preInit"] = [Module["preInit"]];
        while (Module["preInit"].length > 0) {
          Module["preInit"].pop()()
        }
      }
      run();


      return Module.ready
    }
  );
})();
if (typeof exports === 'object' && typeof module === 'object') {
  console.log('模块');
  module.exports = Module;
} else if (typeof define === 'function' && define['amd']) {
  console.log('adm');
  define([], function() {
    return Module;
  });
} else if (typeof exports === 'object') {
  console.log('模块对象');
  exports["Module"] = Module;
}
